package org.nox.helloseries.server.services;

import java.util.Date;
import java.util.Timer;
import java.util.TimerTask;

import org.apache.commons.collections.CollectionUtils;
import org.nox.helloseries.configuration.CustomConfiguration;
import org.nox.helloseries.configuration.CustomConfigurationKey;
import org.nox.helloseries.domain.Serie;
import org.nox.helloseries.domain.recherche.RetourRechercheTracker;
import org.nox.helloseries.factory.HelloSeriesServiceFactory;
import org.nox.helloseries.server.services.configuration.SerieConfigurationService;
import org.nox.helloseries.server.services.download.TorrentService;
import org.nox.helloseries.server.services.recherche.TrackerSearchService;
import org.nox.helloseries.server.utils.ServerUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class AsyncSearchTimer extends Timer
{
    private static Logger LOG = LoggerFactory.getLogger( AsyncSearchTimer.class );

    // Récupération des services
    // Import des services
    private TrackerSearchService trackerSearchService = HelloSeriesServiceFactory.createOrGetService( TrackerSearchService.class );

    private SerieConfigurationService serieConfigurationService = HelloSeriesServiceFactory.createOrGetService( SerieConfigurationService.class );

    private TorrentService torrentService = HelloSeriesServiceFactory.createOrGetService( TorrentService.class );

    public AsyncSearchTimer()
    {
        LOG.info( "Préparation du process de recherche - récurrant toutes les " + ServerUtils.millisPrettyPrint( CustomConfiguration.get().getInteger( CustomConfigurationKey.TIME_JOB ) ) );
    }

    public synchronized void start()
    {
        this.schedule( new TimerTask()
        {
            public void run()
            {
                // Récupération des séries à télécharger suivant la conf
                LOG.info( "Récupération des séries à télécharger suivant la conf" );
                RetourRechercheTracker retour = trackerSearchService.searchAll();
                if ( retour != null )
                {

                    if ( CollectionUtils.isNotEmpty( retour.getSeriesToBeDownloaded() ) )
                    {
                        LOG.info( "Envoi à transmission-daemon des séries" );
                        for ( Serie serieToBeDownloaded : retour.getSeriesToBeDownloaded() )
                        {
                            if ( !torrentService.startDownload( serieToBeDownloaded ) )
                            {
                                LOG.error( "Impossible de télécharger la série : " + serieToBeDownloaded );
                                // Remise à zéro de celle ci dans la liste des séries à update
                                LOG.info( "La configuration de cette série ne sera pas mise à jour" );
                                for ( Serie serie : retour.getSeriesARechercherUpdated() )
                                {
                                    // on vérifie la série configurée correspondante est présente
                                    if ( serie.getNom().equals( serieToBeDownloaded.getNom() ) && serie.getQualite() == serieToBeDownloaded.getQualite()
                                        && serie.getVersion() == serieToBeDownloaded.getVersion() && serie.isActive() )
                                    {
                                        // FIXME cette bidouille ne marchera toujours pas si ca plante entre un changement de saison
                                        serie.setEpisode( serieToBeDownloaded.getEpisode() - 1 );
                                        serie.setSaison( serieToBeDownloaded.getSaison() );
                                    }
                                }
                            }
                        }
                        LOG.info( "Fin de l'envoi à transmission-daemon des séries" );

                        LOG.info( "Sauvegarde de la conf des séries" );
                        serieConfigurationService.saveSeries( retour.getSeriesARechercherUpdated() );
                    }
                    else
                    {
                        LOG.info( "Aucun résultat" );
                    }
                }
                else
                {
                    LOG.error( "Récupération des séries impossible, nouvelle tentative dans {} ms ", CustomConfiguration.get().getInteger( CustomConfigurationKey.TIME_JOB ) );
                }

            }
        }, new Date(), CustomConfiguration.get().getInteger( CustomConfigurationKey.TIME_JOB ) );
    }
}
